(1) Field of the Invention
The present invention relates to a self-aware computing system. More specifically, the present invention relates to a computing system that allows for levels of self-monitoring and behavior modification by incorporating observer processors which operate independently of actor processors that carry out system operations.
(2) Description of Related Art
Self-awareness generally refers to an ability to reason about one's own actions and thoughts. An important part of this concept is an ability to reflect upon one's own actions and consider the consequences of those actions before they occur. More fundamentally, however, self-awareness is generally considered an ability to mentally stand outside oneself and reason as an observer or on-looker peering into the mind of another. In its simplest form, having the ability for a computer to detect when it is in an undesirable operating state would constitute at least some modicum of self-aware computing that is rarely seen. Despite impressive advantages in computing technology over the last few decades, generating self-awareness in machines remains an unresolved problem.
One of the primary difficulties in generating “true” self-awareness lies in the fact that there are limitations to generating awareness using a single processing device. As an example, two processes, an actor process and an observer process, cannot run on the same hardware without tending to interfere with one another. This is because the very act of making an observation changes the state of the system being observed, this claim applying to software in a case where the software attempts to observe hardware states of the machine upon which it runs. Consider, for example, two programs running on the same hardware. Suppose that one of the two programs, an observer process, is designed to monitor the hard disk access patterns of the other. To do this, the first program occasionally uses computing resources itself, including the hard disk. Thus, in the course of switching between programs, the computer hardware may ultimately exhibit disk access patterns that are different from those that would be observed with one program running alone. In effect, the observer process has no way to distinguish between patterns that are independent of it and those that are an artifact of its own activity.
On the other hand, if an actor process and an observer process running on the same hardware might interfere with each other, one may consider that simulating two independent machines on a single computer may accomplish the desired level of self-awareness. If possible, this could be attained by running multiple virtual machines on the same processor. However, there are theoretical and practical considerations that make it doubtful that such a configuration would possess properties that would prevent the actions of the observer from altering its own observations. On the theoretical side, there is the issue of clock synchrony. It is known in the art that any simulation of coupled virtual machines running on the same processor must share the same reference clock. Their simulated clocks may run at different rates, but it is impossible for the ratio of frequencies to be anything other than a rational number. In contrast, it is known that for coupled parallel machines with independent clocks, the ratio of clock frequencies will invariably be an irrational number. The physical machines may therefore, in theory, produce results that cannot be generated by application of concurrent machine simulations on the same physical hardware.
Whether or not the above theoretical issue could lead to significant qualitative differences in behavior between concurrent virtual machines and concurrent physical machines remains to be seen. Nevertheless, there are practical considerations that remain. First, each virtual machine is typically a very abstract version of a physical machine. It has no disk drives, no adder circuits, no input/output buffers, etc. This means that ultimately there is no access to the underlying semantics of the machine itself. Of course, a machine could always be simulated all the way down to the individual gates, logic circuits, and disk drives. However, any attempt to do so would still leave behind some of the semantics of the machine. Even if one argues that there is a limit on how far one may need to go, it is clear that approaching this limit is highly impractical. As a machine tries to simulate itself to greater and greater degrees of precision, the fewer resources it has available to do anything else, and all interactivity will be lost.
There are many instances of multiple processor systems that provide a degree of self-monitoring (in many cases, limited to a form of operational redundancy), such as those used in mission-critical systems, with typical configurations including two or more processors, each running the same software and linked together in a voting scheme. Some mission-critical systems incorporate an active processor and a shadow processor which runs parallel to the actor in order to help to detect runtime errors. There are several different versions of this approach. In one version, the shadow processor runs the same instructions as the active processor so that the shadow processor may be switched in when a failure occurs in the active processor or so that the active processor can be restarted. In another version, the shadow processor runs a variant of the program running on the active processor. This version may be used to track pointer and memory allocation to detect run-time errors in the main program. In yet another version, code branches are speculatively executed to assist in pre-fetching data for the active processor's cache. Typically, where shadow processors and active processors communicate, they do so through a common memory mechanism.
In methods of monitoring utilizing shadow-processors, the shadow processor generally emulates the activities of the active processor in some way. This means that that shadow processor is still bound to the confines of the same inputs and outputs as the active processor. Thus, while the shadow processor may be able to detect certain run-time errors in the code of the active processor, it still cannot easily detect anomalous behavior of the active processor that might result from unexpected inputs. A good example of this is a network switch. The code on the switch might be free of pointer overflow or memory allocation errors, yet when the switch is subject to certain network traffic, it may behave badly. Adjusting a parameter in the code may solve this problem, but the code itself has no way of reflecting upon its own behavior, regardless of whether the code is running on the active processor or the shadow processor—not, at least, without slowing down its own performance, thereby altering the processor's behavior in an undesirable way.
In light of the current state of the art, there exists a need for a reliable self-aware computing system that includes an observer processor that operates independent of an actor processor. Such a system would allow the observer processor to monitor the actor processor without altering the actor processor in any way until a need arises. Such a system would also isolate the observer processor from the actor processor such that instructions running on the actor processor cannot be used to directly control the observer processor.